This is an archive of the discontinued LLVM Phabricator instance.

Differential D46209

[Support] Make JSON handle doubles and int64s losslessly
ClosedPublic

Authored by sammccall on Apr 27 2018, 1:18 PM.

Details

Reviewers
simon_tatham
Commits
rGd93eaeb7c399: [Support] Make JSON handle doubles and int64s losslessly
rL336541: [Support] Make JSON handle doubles and int64s losslessly
Summary

This patch adds a new "integer" ValueType, and renames Number -> Double.
This allows us to preserve the full precision of int64_t when parsing integers
from the wire, or constructing from an integer.
The API is unchanged, other than giving asInteger() a clearer contract.

In addition, always output doubles with enough precision that parsing will
reconstruct the same double.

Diff Detail

Repository
rL LLVM

Event Timeline

sammccall created this revision.Apr 27 2018, 1:18 PM
Herald added a subscriber: llvm-commits. · View Herald TranscriptApr 27 2018, 1:18 PM
sammccall added a parent revision: D45753: Lift JSON library from clang-tools-extra/clangd to llvm/Support..Apr 27 2018, 1:20 PM
sammccall updated this revision to Diff 144391.Apr 27 2018, 1:32 PM

Clarify docs, add deserializer for int64_t

Harbormaster completed remote builds in B17507: Diff 144391.Apr 27 2018, 1:32 PM
sammccall mentioned this in D45753: Lift JSON library from clang-tools-extra/clangd to llvm/Support..Apr 27 2018, 2:13 PM
simon_tatham added a comment.Apr 28 2018, 6:41 AM

Other than these nitpicks, this looks good to me. I've rebased my tablegen patch on to it and confirmed that it now handles integers the way I'd like it to, without me having had to change a line of my client code.

lib/Support/JSON.cpp
347 ↗(On Diff #144391)

Tiniest nitpick ever: in this function you've explicitly said std::strtod, but used strtoll unqualified. I wasn't able to figure out which of <cstdlib> and <stdlib.h> actually ends up being included by the headers this file asks for, but std::strtoll would probably be safer, just in case it's <cstdlib>.

unittests/Support/JSONTest.cpp
268 ↗(On Diff #144391)

You mentioned in D45753 that there might at some point be a need to handle uint64_t as well as int64_t. Given that, it might make sense to include some tests of negative integers now, so that if that does need to be added later, we'll catch any accidental breakage of the negative integer tests?

simon_tatham added a child revision: D46054: [TableGen] Add a general-purpose JSON backend..Apr 30 2018, 7:57 AM
simon_tatham mentioned this in D46054: [TableGen] Add a general-purpose JSON backend..Apr 30 2018, 8:20 AM
sammccall marked 2 inline comments as done.Apr 30 2018, 10:33 AM

Thanks for verifying this! (Still waiting for a decision on the master patch, I hope this doesn't block you too long!)

unittests/Support/JSONTest.cpp
268 ↗(On Diff #144391)

Done. I *really* hope we never have to support both at once!

sammccall updated this revision to Diff 144588.Apr 30 2018, 10:33 AM
sammccall marked an inline comment as done.

Negative number test case, fix std:: qualification.

simon_tatham accepted this revision.May 1 2018, 1:09 AM

LGTM. Thanks!

This revision is now accepted and ready to land.May 1 2018, 1:09 AM
simon_tatham added a subscriber: nhaehnle.May 30 2018, 6:20 AM
This comment was removed by simon_tatham.
simon_tatham added a comment.May 30 2018, 6:21 AM

Oops – posted a comment in the wrong browser tab :-( Sorry for the noise, and especially sorry to @nhaehnle who I didn't actually intend to subscribe to this review.

nhaehnle removed a subscriber: nhaehnle.May 30 2018, 6:33 AM
sammccall updated this revision to Diff 154577.Jul 9 2018, 5:08 AM

Rebase

Closed by commit rL336541: [Support] Make JSON handle doubles and int64s losslessly (authored by sammccall). · Explain WhyJul 9 2018, 5:21 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Support/
60 lines
lib/
Support/
42 lines
unittests/
Support/
60 lines

Diff 154579

llvm/trunk/include/llvm/Support/JSON.h

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines
/// These can be list-initialized, or used to build up collections in a loop. /// These can be list-initialized, or used to build up collections in a loop.
/// json::ary(Collection) converts all items in a collection to Values. /// json::ary(Collection) converts all items in a collection to Values.
/// ///
/// === Inspecting values === /// === Inspecting values ===
/// ///
/// Each Value is one of the JSON kinds: /// Each Value is one of the JSON kinds:
/// null (nullptr_t) /// null (nullptr_t)
/// boolean (bool) /// boolean (bool)
/// number (double) /// number (double or int64)
/// string (StringRef) /// string (StringRef)
/// array (json::Array) /// array (json::Array)
/// object (json::Object) /// object (json::Object)
/// ///
/// The kind can be queried directly, or implicitly via the typed accessors: /// The kind can be queried directly, or implicitly via the typed accessors:
/// if (Optional<StringRef> S = E.getAsString() /// if (Optional<StringRef> S = E.getAsString()
/// assert(E.kind() == Value::String); /// assert(E.kind() == Value::String);
/// ///
/// Array and Object also have typed indexing accessors for easy traversal: /// Array and Object also have typed indexing accessors for easy traversal:
/// Expected<Value> E = parse(R"( {"options": {"font": "sans-serif"}} )"); /// Expected<Value> E = parse(R"( {"options": {"font": "sans-serif"}} )");
/// if (Object* O = E->getAsObject()) /// if (Object* O = E->getAsObject())
/// if (Object* Opts = O->getObject("options")) /// if (Object* Opts = O->getObject("options"))
/// if (Optional<StringRef> Font = Opts->getString("font")) /// if (Optional<StringRef> Font = Opts->getString("font"))
/// assert(Opts->at("font").kind() == Value::String); /// assert(Opts->at("font").kind() == Value::String);
/// ///
/// === Converting JSON values to C++ types === /// === Converting JSON values to C++ types ===
/// ///
/// The convention is to have a deserializer function findable via ADL: /// The convention is to have a deserializer function findable via ADL:
/// fromJSON(const json::Value&, T&)->bool /// fromJSON(const json::Value&, T&)->bool
/// Deserializers are provided for: /// Deserializers are provided for:
/// - bool /// - bool
/// - int /// - int and int64_t
/// - double /// - double
/// - std::string /// - std::string
/// - vector<T>, where T is deserializable /// - vector<T>, where T is deserializable
/// - map<string, T>, where T is deserializable /// - map<string, T>, where T is deserializable
/// - Optional<T>, where T is deserializable /// - Optional<T>, where T is deserializable
/// ObjectMapper can help writing fromJSON() functions for object types. /// ObjectMapper can help writing fromJSON() functions for object types.
/// ///
/// For conversion in the other direction, the serializer function is: /// For conversion in the other direction, the serializer function is:
Show All 11 Lines
/// And parsed: /// And parsed:
/// Expected<Value> E = json::parse("[1, 2, null]"); /// Expected<Value> E = json::parse("[1, 2, null]");
/// assert(E && E->kind() == Value::Array); /// assert(E && E->kind() == Value::Array);
class Value { class Value {
public: public:
enum Kind { enum Kind {
Null, Null,
Boolean, Boolean,
/// Number values can store both int64s and doubles at full precision,
/// depending on what they were constructed/parsed from.
Number, Number,
String, String,
Array, Array,
Object, Object,
}; };
// It would be nice to have Value() be null. But that would make {} null too. // It would be nice to have Value() be null. But that would make {} null too.
Value(const Value &M) { copyFrom(M); } Value(const Value &M) { copyFrom(M); }
Show All 11 Linespublic:
Value(const llvm::SmallVectorImpl<char> &V) : Type(T_String) { Value(const llvm::SmallVectorImpl<char> &V) : Type(T_String) {
create<std::string>(V.begin(), V.end()); create<std::string>(V.begin(), V.end());
} }
Value(const llvm::formatv_object_base &V) : Value(V.str()){}; Value(const llvm::formatv_object_base &V) : Value(V.str()){};
// Strings: types with reference semantics. // Strings: types with reference semantics.
Value(llvm::StringRef V) : Type(T_StringRef) { create<llvm::StringRef>(V); } Value(llvm::StringRef V) : Type(T_StringRef) { create<llvm::StringRef>(V); }
Value(const char *V) : Type(T_StringRef) { create<llvm::StringRef>(V); } Value(const char *V) : Type(T_StringRef) { create<llvm::StringRef>(V); }
Value(std::nullptr_t) : Type(T_Null) {} Value(std::nullptr_t) : Type(T_Null) {}
// Prevent implicit conversions to boolean. // Boolean (disallow implicit conversions).
template <typename T, typename = typename std::enable_if< // (The last template parameter is a dummy to keep templates distinct.)
std::is_same<T, bool>::value>::type> template <
typename T,
typename = typename std::enable_if<std::is_same<T, bool>::value>::type,
bool = false>
Value(T B) : Type(T_Boolean) { Value(T B) : Type(T_Boolean) {
create<bool>(B); create<bool>(B);
} }
// Numbers: arithmetic types that are not boolean. // Integers (except boolean). Must be non-narrowing convertible to int64_t.
template < template <
typename T, typename T,
typename = typename std::enable_if<std::is_arithmetic<T>::value>::type, typename = typename std::enable_if<std::is_integral<T>::value>::type,
typename = typename std::enable_if<!std::is_same<T, bool>::value>::type> typename = typename std::enable_if<!std::is_same<T, bool>::value>::type>
Value(T D) : Type(T_Number) { Value(T I) : Type(T_Integer) {
create<double>(D); create<int64_t>(int64_t{I});
}
// Floating point. Must be non-narrowing convertible to double.
template <typename T,
typename =
typename std::enable_if<std::is_floating_point<T>::value>::type,
double * = nullptr>
Value(T D) : Type(T_Double) {
create<double>(double{D});
} }
// Serializable types: with a toJSON(const T&)->Value function, found by ADL. // Serializable types: with a toJSON(const T&)->Value function, found by ADL.
template <typename T, template <typename T,
typename = typename std::enable_if<std::is_same< typename = typename std::enable_if<std::is_same<
Value, decltype(toJSON(*(const T *)nullptr))>::value>> Value, decltype(toJSON(*(const T *)nullptr))>::value>,
Value * = nullptr>
Value(const T &V) : Value(toJSON(V)) {} Value(const T &V) : Value(toJSON(V)) {}
Value &operator=(const Value &M) { Value &operator=(const Value &M) {
destroy(); destroy();
copyFrom(M); copyFrom(M);
return *this; return *this;
} }
Value &operator=(Value &&M) { Value &operator=(Value &&M) {
destroy(); destroy();
moveFrom(std::move(M)); moveFrom(std::move(M));
return *this; return *this;
} }
~Value() { destroy(); } ~Value() { destroy(); }
Kind kind() const { Kind kind() const {
switch (Type) { switch (Type) {
case T_Null: case T_Null:
return Null; return Null;
case T_Boolean: case T_Boolean:
return Boolean; return Boolean;
case T_Number: case T_Double:
case T_Integer:
return Number; return Number;
case T_String: case T_String:
case T_StringRef: case T_StringRef:
return String; return String;
case T_Object: case T_Object:
return Object; return Object;
case T_Array: case T_Array:
return Array; return Array;
} }
llvm_unreachable("Unknown kind"); llvm_unreachable("Unknown kind");
} }
// Typed accessors return None/nullptr if the Value is not of this type. // Typed accessors return None/nullptr if the Value is not of this type.
llvm::Optional<std::nullptr_t> getAsNull() const { llvm::Optional<std::nullptr_t> getAsNull() const {
if (LLVM_LIKELY(Type == T_Null)) if (LLVM_LIKELY(Type == T_Null))
return nullptr; return nullptr;
return llvm::None; return llvm::None;
} }
llvm::Optional<bool> getAsBoolean() const { llvm::Optional<bool> getAsBoolean() const {
if (LLVM_LIKELY(Type == T_Boolean)) if (LLVM_LIKELY(Type == T_Boolean))
return as<bool>(); return as<bool>();
return llvm::None; return llvm::None;
} }
llvm::Optional<double> getAsNumber() const { llvm::Optional<double> getAsNumber() const {
if (LLVM_LIKELY(Type == T_Number)) if (LLVM_LIKELY(Type == T_Double))
return as<double>(); return as<double>();
if (LLVM_LIKELY(Type == T_Integer))
return as<int64_t>();
return llvm::None; return llvm::None;
} }
// Succeeds if the Value is a Number, and exactly representable as int64_t.
llvm::Optional<int64_t> getAsInteger() const { llvm::Optional<int64_t> getAsInteger() const {
if (LLVM_LIKELY(Type == T_Number)) { if (LLVM_LIKELY(Type == T_Integer))
return as<int64_t>();
if (LLVM_LIKELY(Type == T_Double)) {
double D = as<double>(); double D = as<double>();
if (LLVM_LIKELY(std::modf(D, &D) == 0.0 && if (LLVM_LIKELY(std::modf(D, &D) == 0.0 &&
D >= double(std::numeric_limits<int64_t>::min()) && D >= double(std::numeric_limits<int64_t>::min()) &&
D <= double(std::numeric_limits<int64_t>::max()))) D <= double(std::numeric_limits<int64_t>::max())))
return D; return D;
} }
return llvm::None; return llvm::None;
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesprivate:
template <typename Indenter> template <typename Indenter>
void print(llvm::raw_ostream &, const Indenter &) const; void print(llvm::raw_ostream &, const Indenter &) const;
friend struct llvm::format_provider<llvm::json::Value>; friend struct llvm::format_provider<llvm::json::Value>;
enum ValueType : char { enum ValueType : char {
T_Null, T_Null,
T_Boolean, T_Boolean,
// FIXME: splitting Number into Double and Integer would allow us to T_Double,
// round-trip 64-bit integers. T_Integer,
T_Number,
T_StringRef, T_StringRef,
T_String, T_String,
T_Object, T_Object,
T_Array, T_Array,
}; };
// All members mutable, see moveFrom(). // All members mutable, see moveFrom().
mutable ValueType Type; mutable ValueType Type;
mutable llvm::AlignedCharArrayUnion<bool, double, llvm::StringRef, mutable llvm::AlignedCharArrayUnion<bool, double, int64_t, llvm::StringRef,
std::string, json::Array, json::Object> std::string, json::Array, json::Object>
Union; Union;
}; };
bool operator==(const Value &, const Value &); bool operator==(const Value &, const Value &);
inline bool operator!=(const Value &L, const Value &R) { return !(L == R); } inline bool operator!=(const Value &L, const Value &R) { return !(L == R); }
llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Value &); llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Value &);
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
} }
inline bool fromJSON(const Value &E, int &Out) { inline bool fromJSON(const Value &E, int &Out) {
if (auto S = E.getAsInteger()) { if (auto S = E.getAsInteger()) {
Out = *S; Out = *S;
return true; return true;
} }
return false; return false;
} }
inline bool fromJSON(const Value &E, int64_t &Out) {
if (auto S = E.getAsInteger()) {
Out = *S;
return true;
}
return false;
}
inline bool fromJSON(const Value &E, double &Out) { inline bool fromJSON(const Value &E, double &Out) {
if (auto S = E.getAsNumber()) { if (auto S = E.getAsNumber()) {
Out = *S; Out = *S;
return true; return true;
} }
return false; return false;
} }
inline bool fromJSON(const Value &E, bool &Out) { inline bool fromJSON(const Value &E, bool &Out) {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/trunk/lib/Support/JSON.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
Value::Value(std::initializer_list<Value> Elements) Value::Value(std::initializer_list<Value> Elements)
: Value(json::Array(Elements)) {} : Value(json::Array(Elements)) {}
void Value::copyFrom(const Value &M) { void Value::copyFrom(const Value &M) {
Type = M.Type; Type = M.Type;
switch (Type) { switch (Type) {
case T_Null: case T_Null:
case T_Boolean: case T_Boolean:
case T_Number: case T_Double:
case T_Integer:
memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer)); memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer));
break; break;
case T_StringRef: case T_StringRef:
create<StringRef>(M.as<StringRef>()); create<StringRef>(M.as<StringRef>());
break; break;
case T_String: case T_String:
create<std::string>(M.as<std::string>()); create<std::string>(M.as<std::string>());
break; break;
case T_Object: case T_Object:
create<json::Object>(M.as<json::Object>()); create<json::Object>(M.as<json::Object>());
break; break;
case T_Array: case T_Array:
create<json::Array>(M.as<json::Array>()); create<json::Array>(M.as<json::Array>());
break; break;
} }
} }
void Value::moveFrom(const Value &&M) { void Value::moveFrom(const Value &&M) {
Type = M.Type; Type = M.Type;
switch (Type) { switch (Type) {
case T_Null: case T_Null:
case T_Boolean: case T_Boolean:
case T_Number: case T_Double:
case T_Integer:
memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer)); memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer));
break; break;
case T_StringRef: case T_StringRef:
create<StringRef>(M.as<StringRef>()); create<StringRef>(M.as<StringRef>());
break; break;
case T_String: case T_String:
create<std::string>(std::move(M.as<std::string>())); create<std::string>(std::move(M.as<std::string>()));
M.Type = T_Null; M.Type = T_Null;
break; break;
case T_Object: case T_Object:
create<json::Object>(std::move(M.as<json::Object>())); create<json::Object>(std::move(M.as<json::Object>()));
M.Type = T_Null; M.Type = T_Null;
break; break;
case T_Array: case T_Array:
create<json::Array>(std::move(M.as<json::Array>())); create<json::Array>(std::move(M.as<json::Array>()));
M.Type = T_Null; M.Type = T_Null;
break; break;
} }
} }
void Value::destroy() { void Value::destroy() {
switch (Type) { switch (Type) {
case T_Null: case T_Null:
case T_Boolean: case T_Boolean:
case T_Number: case T_Double:
case T_Integer:
break; break;
case T_StringRef: case T_StringRef:
as<StringRef>().~StringRef(); as<StringRef>().~StringRef();
break; break;
case T_String: case T_String:
as<std::string>().~basic_string(); as<std::string>().~basic_string();
break; break;
case T_Object: case T_Object:
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
private: private:
void eatWhitespace() { void eatWhitespace() {
while (P != End && (*P == ' ' || *P == '\r' || *P == '\n' || *P == '\t')) while (P != End && (*P == ' ' || *P == '\r' || *P == '\n' || *P == '\t'))
++P; ++P;
} }
// On invalid syntax, parseX() functions return false and set Err. // On invalid syntax, parseX() functions return false and set Err.
bool parseNumber(char First, double &Out); bool parseNumber(char First, Value &Out);
bool parseString(std::string &Out); bool parseString(std::string &Out);
bool parseUnicode(std::string &Out); bool parseUnicode(std::string &Out);
bool parseError(const char *Msg); // always returns false bool parseError(const char *Msg); // always returns false
char next() { return P == End ? 0 : *P++; } char next() { return P == End ? 0 : *P++; }
char peek() { return P == End ? 0 : *P; } char peek() { return P == End ? 0 : *P; }
static bool isNumber(char C) { static bool isNumber(char C) {
return C == '0' || C == '1' || C == '2' || C == '3' || C == '4' || return C == '0' || C == '1' || C == '2' || C == '3' || C == '4' ||
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines for (;;) {
case '}': case '}':
return true; return true;
default: default:
return parseError("Expected , or } after object property"); return parseError("Expected , or } after object property");
} }
} }
} }
default: default:
if (isNumber(C)) { if (isNumber(C))
double Num; return parseNumber(C, Out);
if (parseNumber(C, Num)) {
Out = Num;
return true;
} else {
return false;
}
}
return parseError("Invalid JSON value"); return parseError("Invalid JSON value");
} }
} }
bool Parser::parseNumber(char First, double &Out) { bool Parser::parseNumber(char First, Value &Out) {
// Read the number into a string. (Must be null-terminated for strto*).
SmallString<24> S; SmallString<24> S;
S.push_back(First); S.push_back(First);
while (isNumber(peek())) while (isNumber(peek()))
S.push_back(next()); S.push_back(next());
char *End; char *End;
// Try first to parse as integer, and if so preserve full 64 bits.
// strtoll returns long long >= 64 bits, so check it's in range too.
auto I = std::strtoll(S.c_str(), &End, 10);
if (End == S.end() && I >= std::numeric_limits<int64_t>::min() &&
I <= std::numeric_limits<int64_t>::max()) {
Out = int64_t(I);
return true;
}
// If it's not an integer
Out = std::strtod(S.c_str(), &End); Out = std::strtod(S.c_str(), &End);
return End == S.end() || parseError("Invalid JSON value (number?)"); return End == S.end() || parseError("Invalid JSON value (number?)");
} }
bool Parser::parseString(std::string &Out) { bool Parser::parseString(std::string &Out) {
// leading quote was already consumed. // leading quote was already consumed.
for (char C = next(); C != '"'; C = next()) { for (char C = next(); C != '"'; C = next()) {
if (LLVM_UNLIKELY(P == End)) if (LLVM_UNLIKELY(P == End))
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
void llvm::json::Value::print(raw_ostream &OS, const Indenter &I) const { void llvm::json::Value::print(raw_ostream &OS, const Indenter &I) const {
switch (Type) { switch (Type) {
case T_Null: case T_Null:
OS << "null"; OS << "null";
break; break;
case T_Boolean: case T_Boolean:
OS << (as<bool>() ? "true" : "false"); OS << (as<bool>() ? "true" : "false");
break; break;
case T_Number: case T_Double:
OS << format("%g", as<double>()); OS << format("%.*g", std::numeric_limits<double>::max_digits10,
as<double>());
break;
case T_Integer:
OS << as<int64_t>();
break; break;
case T_StringRef: case T_StringRef:
quote(OS, as<StringRef>()); quote(OS, as<StringRef>());
break; break;
case T_String: case T_String:
quote(OS, as<std::string>()); quote(OS, as<std::string>());
break; break;
case T_Object: { case T_Object: {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/trunk/unittests/Support/JSONTest.cpp

Show First 20 Lines • Show All 221 Lines • ▼ Show 20 Lines if (I++ == 5) {
ASSERT_TRUE(E.getAsObject()); ASSERT_TRUE(E.getAsObject());
EXPECT_EQ(E.getAsObject()->getString("time"), EXPECT_EQ(E.getAsObject()->getString("time"),
llvm::Optional<llvm::StringRef>("arrow")); llvm::Optional<llvm::StringRef>("arrow"));
} else } else
EXPECT_FALSE(E.getAsObject()); EXPECT_FALSE(E.getAsObject());
} }
} }
// Verify special integer handling - we try to preserve exact int64 values.
TEST(JSONTest, Integers) {
struct {
const char *Desc;
Value Val;
const char *Str;
llvm::Optional<int64_t> AsInt;
llvm::Optional<double> AsNumber;
} TestCases[] = {
{
"Non-integer. Stored as double, not convertible.",
double{1.5},
"1.5",
llvm::None,
1.5,
},
{
"Integer, not exact double. Stored as int64, convertible.",
int64_t{0x4000000000000001},
"4611686018427387905",
int64_t{0x4000000000000001},
double{0x4000000000000000},
},
{
"Negative integer, not exact double. Stored as int64, convertible.",
int64_t{-0x4000000000000001},
"-4611686018427387905",
int64_t{-0x4000000000000001},
double{-0x4000000000000000},
},
{
"Dynamically exact integer. Stored as double, convertible.",
double{0x6000000000000000},
"6.9175290276410819e+18",
int64_t{0x6000000000000000},
double{0x6000000000000000},
},
{
"Dynamically integer, >64 bits. Stored as double, not convertible.",
1.5 * double{0x8000000000000000},
"1.3835058055282164e+19",
llvm::None,
1.5 * double{0x8000000000000000},
},
};
for (const auto &T : TestCases) {
EXPECT_EQ(T.Str, s(T.Val)) << T.Desc;
llvm::Expected<Value> Doc = parse(T.Str);
EXPECT_TRUE(!!Doc) << T.Desc;
EXPECT_EQ(Doc->getAsInteger(), T.AsInt) << T.Desc;
EXPECT_EQ(Doc->getAsNumber(), T.AsNumber) << T.Desc;
EXPECT_EQ(T.Val, *Doc) << T.Desc;
EXPECT_EQ(T.Str, s(*Doc)) << T.Desc;
}
}
// Sample struct with typical JSON-mapping rules. // Sample struct with typical JSON-mapping rules.
struct CustomStruct { struct CustomStruct {
CustomStruct() : B(false) {} CustomStruct() : B(false) {}
CustomStruct(std::string S, llvm::Optional<int> I, bool B) CustomStruct(std::string S, llvm::Optional<int> I, bool B)
: S(S), I(I), B(B) {} : S(S), I(I), B(B) {}
std::string S; std::string S;
llvm::Optional<int> I; llvm::Optional<int> I;
bool B; bool B;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines